C++ 排序算法实现 及 性能比较

最新推荐文章于 2024-07-24 23:21:08 发布
最新推荐文章于 2024-07-24 23:21:08 发布
阅读量1.5k 收藏 4
点赞数
分类专栏： 算法与数据结构 C++基础知识 文章标签： C++-排序算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lanwanjunxixihaha/article/details/50637145
版权 

#include <iostream>
#include <queue>
#include <math.h>
#include <WINDOWS.H>
#include <time.h>

typedef int ArrayElemType;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//计数排序
void CountSort(ArrayElemType arr[],int size){
    int max=arr[0],min=arr[0],i=0;
    for(i=1;i<size;i++){
        if(max<arr[i]){
            max=arr[i];
        }
        if(min>arr[i]){
            min=arr[i]; 
        }
    }
    if(min<0)return;
    int countSize=max+1;
    int *count = new int[countSize];
    ArrayElemType *sort = new ArrayElemType[size];
    memset(count,0,countSize*4);
    for(i=0;i<size;i++){
        count[arr[i]]++;
    }
    for(i=1;i<countSize;i++){
        count[i]+=count[i-1];
    }
    for(i=size-1;i>=0;i--){
        int rank=count[arr[i]]--;
        sort[rank-1]=arr[i];
    }
    memcpy(arr,sort,size*sizeof(ArrayElemType));
    delete[] count;
    delete[] sort;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//快排基准数归位，从小到大排序
int Partition(ArrayElemType array[],int low,int high){
    ArrayElemType pivot = array[low];
    while(low<high){
        while(low<high&&array[high]>=pivot)high--;
        array[low]=array[high];
        while(low<high&&array[low]<=pivot)low++;
        array[high]=array[low];
    }
    array[low]=pivot;
    return low; 
}

//快排
void QuickSort(ArrayElemType array[],int low,int high){
    if(low>=high)
        return;
    int mid=Partition(array,low,high);
    QuickSort(array,low,mid-1);
    QuickSort(array,mid+1,high);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef int HeapElemType;
#define HeapLeft(i) (2*i+1)
#define HeapRight(i) (2*i+2)
#define HeapParent(i) ((i-1)/2)
void InitMinHeap(HeapElemType arr[],int size){
    int cur=0,curVal;
    for(int i=size/2-1;i>=0;i--){
        cur=i;
        curVal=arr[cur];
        for(int j=HeapLeft(cur);j<size;j=HeapLeft(j)){
            if(j+1<size&&arr[j]>arr[j+1])
                j++;
            if(curVal>arr[j]){
                arr[cur]=arr[j];
                cur=j;
            }else{
                break;
            }
        }
        arr[cur]=curVal;
    }
}

int MinHeapDelete(HeapElemType arr[],int size){
    int temp=arr[0];
    arr[0]=arr[size-1];
    arr[size-1]=temp;
    int curVal=arr[0],cur=0;
    size--;
    for(int j=HeapLeft(cur);j<size;j=HeapLeft(j)){
        if(j+1<size&&arr[j]>arr[j+1])
            j++;
        if(curVal>arr[j]){
            arr[cur]=arr[j];
            cur=j;
        }else{
            break;
        }
    }
    arr[cur]=curVal;
    return size;
}

//堆排序
void MinHeapSort(HeapElemType arr[],int size){
    while(size>1){
        size=MinHeapDelete(arr,size);
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//a为前半部分，b为后半部分，合并的过程理解成排序的过程，c是辅助数组
void MergeArray(ArrayElemType a[],int sa,ArrayElemType b[],int sb,ArrayElemType c[]){
    int ia=0,ib=0,ic=0,i=0;
    while(ia<sa&&ib<sb){
        if(a[ia]<b[ib]){
            c[ic++]=a[ia++];
        }else{
            c[ic++]=b[ib++];
        }
    }
    while(ia<sa){
        c[ic++]=a[ia++];
    }
    while(ib<sb){
        c[ic++]=b[ib++];
    }
    while(i<ic){
        a[i]=c[i];
        i++;
    }
}

void MergeSortRecursion(ArrayElemType a[],int left,int right,ArrayElemType c[]){
    if(left==right)
        return;
    int mid=(left+right)/2;
    MergeSortRecursion(a,left,mid,c);
    MergeSortRecursion(a,mid+1,right,c);
    MergeArray(a+left,mid-left+1,a+mid+1,right-mid,c);
    //ShowArray(a+left,right-left+1);
}

//归并排序
void MergeSort(ArrayElemType a[],int size){
    int *c=new int[size];
    MergeSortRecursion(a,0,size-1,c);
    delete[] c;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//希尔排序
void ShellSort(ArrayElemType array[],int arrlen){
    int i,j;
    ArrayElemType e;
    for(int gap=arrlen/2;gap>0;gap/=2){
        for(i=gap;i<arrlen;i++){
            e=array[i];
            for(j=i;j-gap>=0&&e<array[j-gap];j-=gap){
                array[j]=array[j-gap];
            }
            array[j]=e;
        }
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//基数排序
#define GetNumber(num,idx) (num/((int)pow(10,idx-1))%10)
void RadixSort(ArrayElemType arr[],int size,int digit){
    static int count[10];
    ArrayElemType *sort = new ArrayElemType[size];
    int i=0,digitVal=0,isAllZero=true;
    for(int idx=1;idx<=digit;idx++){
        memset(count,0,40);
        isAllZero=true;
        for(i=0;i<size;i++){
            digitVal=GetNumber(arr[i],idx);
            if(digitVal!=0){
                isAllZero=false;
            }
            count[digitVal]++;
        }
        if(isAllZero)
            break;
        for(i=1;i<10;i++){
            count[i]+=count[i-1];
        }
        for(i=size-1;i>=0;i--){
            int rank=count[GetNumber(arr[i],idx)]--;
            sort[rank-1]=arr[i];
        }
        memcpy(arr,sort,size*sizeof(ArrayElemType));
    }
    delete[] sort;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//折半插入排序
void BinInsertSort(ArrayElemType array[],int arrlen){
    int i,j,left,right,mid;
    ArrayElemType e;
    for(i=1;i<arrlen;i++){
        e=array[i];
        left=0;
        right=i-1;
        while(left<=right){
            mid=(left+right)/2;
            if(array[mid]<e)
                left=mid+1;
            else if(array[mid]>e)
                right=mid-1;
            else{
                left=mid;
                break;
            }
        }
        for(j=i;j>left;j--){
            array[j]=array[j-1];
        }
        array[left]=e;
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//插入排序
void InsertSort(ArrayElemType array[],int arrlen){
    int i,j;
    ArrayElemType e;
    for(i=1;i<arrlen;i++){
        e=array[i];
        for(j=i;j>0&&e<array[j-1];j--){
            array[j]=array[j-1];
        }
        array[j]=e;
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//选择排序
void SelectSort(ArrayElemType arr[],int size){
    ArrayElemType minV=0,minP=0;
    for(int i=0;i<size;i++){
        minV=arr[i];
        minP=i;
        for(int j=i+1;j<size;j++){
            if(minV>arr[j]){
                minP=j;
                minV=arr[j];
            }
        }
        minV=arr[i];
        arr[i]=arr[minP];
        arr[minP]=minV;
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//顺序存储冒泡排序
void BubbleSort(ArrayElemType array[],int low,int high){
    if(low>=high)
        return;
    bool hasBubble=false;
    ArrayElemType e;
    for(int i=low;i<=high;i++){
        hasBubble=false;
        for(int j=high;j>i;j--){
            if(array[j]<array[j-1]){
                hasBubble=true;
                e=array[j];
                array[j]=array[j-1];
                array[j-1]=e;
            }
        }
        if(!hasBubble)
            return;
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//性能测试

struct MyTick{
    MyTick(){
        QueryPerformanceFrequency(&m_liPerfFreq);
    }
    ~MyTick(){

    }
    void start(){
         QueryPerformanceCounter(&m_liPerfStart);
    }
    long stop(){
         QueryPerformanceCounter(&liPerfNow);
         interval=( ((liPerfNow.QuadPart - m_liPerfStart.QuadPart) * 1000)/m_liPerfFreq.QuadPart);
         return interval;
    }
    void show(){
        std::cout<<interval<<std::endl;
    }
    long interval;
    LARGE_INTEGER m_liPerfFreq;
    LARGE_INTEGER m_liPerfStart;
    LARGE_INTEGER liPerfNow;
};

int main(){
    ArrayElemType randArr[50000],testArr[50000];
    int randSize=15000;
    bool showResult=false;
    MyTick tick;
    srand(clock());
    for(;randSize<=50000;randSize+=5000){
        std::cout<<"==============数据规模:"<<randSize<<"=============="<<std::endl;
        for(int i=0;i<randSize;i++){
            randArr[i]=rand();
        }

        memcpy(testArr,randArr,randSize*4);
        tick.start();
        CountSort(testArr,randSize);
        std::cout<<"CountSort ";
        tick.stop();
        tick.show();
        if(showResult)ShowArray(testArr,randSize);

        memcpy(testArr,randArr,randSize*4);
        tick.start();
        QuickSort(testArr,0,randSize-1);
        std::cout<<"QuickSort ";
        tick.stop();
        tick.show();
        if(showResult)ShowArray(testArr,randSize);

        memcpy(testArr,randArr,randSize*4);
        tick.start();
        InitMinHeap(testArr,randSize);
        MinHeapSort(testArr,randSize);
        std::cout<<"MinHeapSort ";
        tick.stop();
        tick.show();
        if(showResult)ShowArray(testArr,randSize);

        memcpy(testArr,randArr,randSize*4);
        tick.start();
        MergeSort(testArr,randSize);
        std::cout<<"MergeSort ";
        tick.stop();
        tick.show();
        if(showResult)ShowArray(testArr,randSize);

        memcpy(testArr,randArr,randSize*4);
        tick.start();
        ShellSort(testArr,randSize);
        std::cout<<"ShellSort ";
        tick.stop();
        tick.show();
        if(showResult)ShowArray(testArr,randSize);

        memcpy(testArr,randArr,randSize*4);
        tick.start();
        RadixSort(testArr,randSize,5);
        std::cout<<"RadixSort ";
        tick.stop();
        tick.show();
        if(showResult)ShowArray(testArr,randSize);

        memcpy(testArr,randArr,randSize*4);
        tick.start();
        BinInsertSort(testArr,randSize);
        std::cout<<"BinInsertSort ";
        tick.stop();
        tick.show();
        if(showResult)ShowArray(testArr,randSize);

        memcpy(testArr,randArr,randSize*4);
        tick.start();
        InsertSort(testArr,randSize);
        std::cout<<"InsertSort ";
        tick.stop();
        tick.show();
        if(showResult)ShowArray(testArr,randSize);

        memcpy(testArr,randArr,randSize*4);
        tick.start();
        SelectSort(testArr,randSize);
        std::cout<<"SelectSort ";
        tick.stop();
        tick.show();
        if(showResult)ShowArray(testArr,randSize);

        memcpy(testArr,randArr,randSize*4);
        tick.start();
        BubbleSort(testArr,0,randSize-1);
        std::cout<<"BubbleSort ";
        tick.stop();
        tick.show();
        if(showResult)ShowArray(testArr,randSize);
    }
    system("Pause");
    return 0;
}

输出结果如下：
==============数据规模:15000==============
CountSort 1
QuickSort 4
MinHeapSort 5
ShellSort 6
MergeSort 6
RadixSort 24
BinInsertSort 273
InsertSort 352
SelectSort 445
BubbleSort 1263
==============数据规模:20000==============
CountSort 1
QuickSort 5
MinHeapSort 6
ShellSort 8
MergeSort 7
RadixSort 32
BinInsertSort 482
InsertSort 621
SelectSort 790
BubbleSort 2246
==============数据规模:25000==============
CountSort 2
QuickSort 6
MinHeapSort 8
ShellSort 11
MergeSort 11
RadixSort 39
BinInsertSort 753
InsertSort 974
SelectSort 1235
BubbleSort 3526
==============数据规模:30000==============
CountSort 2
QuickSort 8
MinHeapSort 9
ShellSort 12
MergeSort 11
RadixSort 47
BinInsertSort 1100
InsertSort 1419
SelectSort 1766
BubbleSort 5081
==============数据规模:35000==============
CountSort 2
QuickSort 9
MinHeapSort 11
ShellSort 15
MergeSort 13
RadixSort 55
BinInsertSort 1480
InsertSort 1913
SelectSort 2408
BubbleSort 6885
==============数据规模:40000==============
CountSort 2
QuickSort 10
MinHeapSort 12
ShellSort 18
MergeSort 15
RadixSort 63
BinInsertSort 1938
InsertSort 2506
SelectSort 3153
BubbleSort 9070
==============数据规模:45000==============
CountSort 3
QuickSort 11
MinHeapSort 14
ShellSort 20
MergeSort 17
RadixSort 70
BinInsertSort 2446
InsertSort 3142
SelectSort 3984
BubbleSort 11445
==============数据规模:50000==============
CountSort 3
QuickSort 13
MinHeapSort 15
ShellSort 24
MergeSort 19
RadixSort 78
BinInsertSort 2997
InsertSort 3861
SelectSort 4906
BubbleSort 14035
以上时间单位为毫秒
可以看出快排，堆排，希尔，归并算法效率还是非常高的，计数排序虽然速度是最快的，但是
以牺牲内存作为代价了，如果小范围排序，计数排序还是可以考虑下的。
基数排序比以上几种要稍慢些，但也不是差太远。
性能最不乐观的就是冒泡了。

lanwanjunxixihaha
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
算法入门＜一＞：C++各种排序算法详解及示例源码
欧特GO
04-28 1878
算法入门＜一＞：C++各种排序算法详解及示例源码
内部排序算法性能比较———c++
07-29
五种内部排序算法性能比较， 1.直接插入排序算法。 2.简单选择排序。 3.希尔排序。 4.归并排序。5.快速排序。分别对交换次数，比较次数，移动次数，时长，时间复杂度进行性能比较。给出十万到百万级数据量的统计结果...
C++-排序算法详解
一然明月(嵌入式)的博客
06-06 1499
排序算法是一种将一组数据按照特定顺序（如升序或降序）进行排列的算法。其主要目的是对一组无序的数据进行整理，使得它们呈现出一定的有序性。主要排序算法有:冒泡排序.插入排序,快速排序.选择排序,归并排序,堆排序.
C++ 六大排序算法实现和比较
406156440的博客
08-20 2616
文章目录一. 快速排序1.1 介绍1.2 函数片段1.3 快排应用二. 归并排序2.1 介绍2.2 函数片段三. 插入排序3.1 介绍3.2 函数片段四. 冒泡排序4.1 介绍4.2 函数片段五. 选择排序5.1 介绍5.2 函数片段六. 桶排序 常用的排序算法 本文介绍多种排序算法, 利用图示进行解析 最后部分是整个可执行带主函数的代码\color{#FF3030}{带主函数的代码}带主函数的代码 一. 快速排序 1.1 介绍 快速排序是一种查找一个值的绝对位置, 根据此位置将序列分成左右两个位置
排序算法：基于C++实现的插入排序、冒泡排序与选择排序
热门推荐
fantasticHQ的博客
04-23 1万+
本文介绍了三种基础的排序算法：插入排序、冒泡排序和选择排序,三种排序适合于小型数据或基本有序的数据集，在实际应用中，更高效的排序算法（如快速排序、归并排序等）通常更受欢迎。
10种排序算法总结及c++代码
baicoo的博客
08-22 1810
排序算法总结 1.冒泡排序 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 算法描述 比较相邻的元素。如果第一个比第二个大，就交换它们两个； 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数； 针对所有的元素重复以上的步骤，除了最后一个； 重复步骤1~3，直
C++实现七种经典排序算法
森的博客
04-08 3264
利用C++实现七种常见的排序算法： 具体的排序方法如下所示： （1）冒泡排序 基本思想：比较相邻的两个数，如果前者比后者大，则进行交换。每一轮排序结束，选出一个未排序中最大的数放到数组后面。常见冒泡排序算法如下所示： void bubblesort(int *arr,int n) { for (int i = 0; i < n; i++) { for (int j = ...
c++十大经典排序算法
客舟中
12-28 6207
代码 1 冒泡排序 冒泡排序是一种简单直观的入门排序算法。它的原理就是从第一个元素开始，与后面的元素逐个比较，如果顺序不对就交换，直到没有可比较的元素为止。 1 // 冒泡排序 2 void BublingSort(int *arr, int len) 3 { 4 if(len == 0) 5 { 6 return; 7 } 8 std::cout<<"冒泡排序"<<std::endl; 9 for(i
快速排序算法的C++实现
qq_40965507的博客
08-25 2187
目录算法描述算法执行过程算法实现算法执行结果算法性能分析参考 算法描述 快速排序又叫分区排序，它是一种平均性能非常好的排序方法。快速排序使用分治思想。这个算法优于归并算法，因为它在原位上排序，不需要辅助的存储空间。对一个数组A[p…r]进行排序一般有三个步骤。 分解：数组A[p…r]被划分为两个子数组A[p…q-1]和A[q+1…r]，是的A[p…q-1]中的每一个元素都小于等于A[q],而A[q]也小于等于A[q+1…r]中的每个元素。同时计算下标q。 递归：通过递归调用快速排序，对子数组A[p…q-1]
【C++】c++排序算法入门之计数排序
qq_39180358的博客
02-19 2135
计数排序（Counting Sort）算法。这是一种非基于比较的排序算法，特别适用于对整数进行排序，尤其是当输入数据范围不是很大时，其性能表现非常出色。
十大排序算法及优化 ( C++简洁实现)
qq_38537501的博客
04-26 2316
十大排序算法 前面的和其他博客内容大差不差，主要可以查看后几种排序算法的分析和代码实现。 归并排序和快速排序为一类（使用递归）; 堆排序：优先队列，在刷题中使用较多； 计数排序、桶排序和基数排序为一类； 我看了很多博客，对于后三种都没有清晰的讲解。在搞清楚之后给大家分享，如果存在错误，请多包涵。 特别需要理解计数排序中累加数组的妙处。 排序算法十大排序算法特别需要理解计数排序中累加数组的妙处。0、算法概述0.1 算法分类0.2 算法复杂度1、冒泡排序（Bubble Sort，稳定）2、选择排序3、插入排序（
C++实现各种排序算法.zip
10-10
总的来说，这个压缩包"**C++实现各种排序算法.zip**"为我们提供了一个宝贵的资源库，可以帮助我们学习和比较不同排序算法的实现，从而提升编程技能，更好地解决实际问题。通过阅读和分析这些代码，我们可以深入理解...
几个排序算法的C++实现
02-03
本项目提供了几个经典的排序算法的C++实现，有助于理解这些算法的工作原理以及如何在实际编程中应用它们。 1. **冒泡排序（Bubble Sort）**： 冒泡排序是一种简单的排序算法，通过不断交换相邻的逆序元素来逐渐把...
Verilog/C++实现排序算法：Verilog/C++实现排序算法：冒泡排序、选择排序、并行全比较排序、串行全比较排序
06-27
本文将探讨如何使用这两种语言实现几种基本的排序算法：冒泡排序、选择排序，以及两种全比较排序（并行和串行）。 首先，让我们了解一下排序算法。排序是计算机科学中最基础的操作之一，它涉及到将一组数据按照特定...
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 622
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
c语言（7.23）
fhgfyrsg的博客
07-23 515
【代码】c语言（7.23）
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 787
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构：逻辑结构与物理结构
最新发布
Weiki的博客
07-24 938
数据结构：逻辑结构与物理结构
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值